Références de méthodes

Une référence de méthode est une syntaxe raccourcie pour une lambda qui ne fait qu'appeler une méthode existante. Quand une lambda se résume à x -> foo(x), on peut l'écrire Classe::foo.

Les références de méthodes sont particulièrement courantes avec les Streams (Cours 06).

Syntaxe générale

Référence           Équivalent lambda
─────────────────   ──────────────────────────────
Classe::méthode     (x) -> Classe.méthode(x)        // statique
instance::méthode   (x) -> instance.méthode(x)      // instance existante
Classe::méthode     (x) -> x.méthode()              // méthode de l'instance reçue
Classe::new         (x) -> new Classe(x)             // constructeur

---

1. Référence à une méthode statique

La méthode référencée est static — elle appartient à la classe, pas à un objet.

import java.util.List;

public class RefStatique {
    public static void afficher(String s) {
        System.out.println(s);
    }

    public static void main(String[] args) {
        List<String> noms = List.of("Alice", "Bob", "Clara");

        // Lambda équivalente : s -> afficher(s)
        noms.forEach(RefStatique::afficher);
    }
}

Integer::parseInt — passer la méthode comme Function<String, Integer> :

import java.util.function.Function;

Function<String, Integer> convertir = Integer::parseInt;
// Lambda équivalente : s -> Integer.parseInt(s)

System.out.println(convertir.apply("42"));  // 42
System.out.println(convertir.apply("7"));   // 7

Math::abs — passer la méthode comme Function<Integer, Integer> :

import java.util.function.Function;

Function<Integer, Integer> valeurAbsolue = Math::abs;
// Lambda équivalente : n -> Math.abs(n)

System.out.println(valeurAbsolue.apply(-5));  // 5
System.out.println(valeurAbsolue.apply(3));   // 3

---

2. Référence à une méthode d'une instance existante

La méthode est appelée sur un objet déjà créé avant la référence.

import java.util.List;

public class RefInstance {
    public static void main(String[] args) {
        List<String> noms = List.of("Alice", "Bob", "Clara");

        // Lambda équivalente : s -> System.out.println(s)
        noms.forEach(System.out::println);
    }
}

Avec un objet créé soi-même — accumuler dans un StringBuilder existant :

import java.util.List;

List<String> mots = List.of("Java", " ", "est", " ", "cool");
StringBuilder sb = new StringBuilder();

// Lambda équivalente : s -> sb.append(s)
mots.forEach(sb::append);

System.out.println(sb.toString()); // Java est cool

3. Référence à une méthode de l'instance reçue

Ici, la méthode est appelée sur l'objet passé en paramètre, pas sur une instance externe.

import java.util.function.Function;

Function<String, String> majuscules = String::toUpperCase;
// Lambda équivalente : s -> s.toUpperCase()

System.out.println(majuscules.apply("alice")); // ALICE
System.out.println(majuscules.apply("bob"));   // BOB

String::length — obtenir la longueur d'un mot :

import java.util.function.Function;

Function<String, Integer> longueur = String::length;
// Lambda équivalente : s -> s.length()

System.out.println(longueur.apply("chat"));     // 4
System.out.println(longueur.apply("éléphant")); // 8

String::isEmpty — tester si une chaîne est vide :

import java.util.function.Predicate;

Predicate<String> estVide = String::isEmpty;
// Lambda équivalente : s -> s.isEmpty()

System.out.println(estVide.test(""));       // true
System.out.println(estVide.test("bonjour")); // false

4. Référence à un constructeur

StringBuilder::new — créer un StringBuilder à partir d'une String :

import java.util.function.Function;

Function<String, StringBuilder> creer = StringBuilder::new;
// Lambda équivalente : s -> new StringBuilder(s)

StringBuilder sb = creer.apply("Bonjour");
System.out.println(sb); // Bonjour

Supplier — créer un objet sans argument :

import java.util.ArrayList;
import java.util.function.Supplier;

Supplier<ArrayList<String>> nouvelleListeVide = ArrayList::new;
// Lambda équivalente : () -> new ArrayList<>()

ArrayList<String> liste = nouvelleListeVide.get();
liste.add("Alice");
System.out.println(liste); // [Alice]

Résumé

Forme	Quand l'utiliser
Classe::méthodeStatique	La méthode ne dépend pas d'une instance
instance::méthode	On a déjà l'objet cible (ex: System.out)
Classe::méthodeInstance	La méthode est appelée sur l'argument reçu
Classe::new	On veut créer un objet à partir de l'argument

Une référence de méthode n'est utilisable que là où une interface fonctionnelle est attendue — exactement comme une lambda.